home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 November / EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso / earcd / unix / mp14tar.z / mp14tar / mpack / macpcstr.c < prev    next >
C/C++ Source or Header  |  1994-06-01  |  7KB  |  373 lines
  1. /* macPCstr.c -- niftyapp library pascal/C combination strings
  2.  *
  3.  * (C) Copyright 1990, 1991 by Christopher J. Newman
  4.  * All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, distribute, and sell this software and its
  7.  * documentation for any purpose is hereby granted without fee, provided that
  8.  * the above copyright notice appear in all copies and that both that
  9.  * copyright notice and this permission notice appear in supporting
  10.  * documentation, and that the name of Christopher J. Newman not be used in
  11.  * advertising or publicity pertaining to distribution of the software without
  12.  * specific, written prior permission.  Christopher J. Newman makes no
  13.  * representations about the suitability of this software for any purpose.  It
  14.  * is provided "as is" without express or implied warranty.
  15.  *
  16.  * CHRISTOPHER J. NEWMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  17.  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT
  18.  * SHALL CHRISTOPHER J. NEWMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  19.  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  20.  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  21.  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  22.  * OF THIS SOFTWARE.
  23.  *
  24.  * Author:    Christopher J. Newman
  25.  * Message:    This is a nifty program.
  26.  *
  27.  *    Created 9/1/88, Assembly Code 6/27/90
  28.  */
  29.  
  30. #ifdef THINK_C
  31. typedef unsigned char PCstr;
  32.  
  33. /* assembler function prototypes */
  34. void PtoPCstrcpy(void);
  35. void CtoPCstrcpy(void);
  36. void PCtoPCstrcpy(void);
  37. void PtoPCstrncpy(void);
  38. void CtoPCstrncpy(void);
  39. void PtoPCstrcat(void);
  40. void CtoPCstrcat(void);
  41. PCstr *PtoPCstr(void);
  42. PCstr *CtoPCstr(void);
  43. void SetPlen(void);
  44. PCstr *longtoPCstr(long);    /* not in assembler */
  45.  
  46. void PtoPCstrcpy( /* PCstr *dest, *src */ )
  47. {
  48.     asm 68000 {
  49.         movea.l    8(sp),a0        ; a0 = src
  50.         movea.l    4(sp),a1        ; a1 = dest
  51.         clr.w    d0
  52.         move.b    (a0),d0
  53.         clr.b    1(a1,d0)
  54.     @loop:
  55.         move.b    (a0)+,(a1)+
  56.         dbf.w    d0,@loop
  57.     }
  58. }
  59.  
  60. void CtoPCstrcpy( /* PCstr *dest, char *src */)
  61. {
  62.     asm 68000 {
  63.         movea.l    8(sp),a0    ; a0 = src
  64.         movea.l    4(sp),a1    ; a1 = dest
  65.         addq.l    #1,a1
  66.         moveq.l    #-1,d0
  67.     @loop:
  68.         addq.w    #1,d0
  69.         move.b    (a0)+,(a1)+
  70.         bne.s    @loop
  71.         movea.l    4(sp),a1    ; a1 = dest
  72.         move.b    d0,(a1)
  73.     }
  74. }
  75.  
  76. void PCtoPCstrcpy( /* PCstr *dest, PCstr *src */)
  77. {
  78.     asm 68000 {
  79.         movea.l    8(sp),a0    ; a0 = src
  80.         movea.l    4(sp),a1    ; a1 = dest
  81.         move.b    (a0)+,(a1)+
  82.     @loop:
  83.         move.b    (a0)+,(a1)+
  84.         bne.s    @loop
  85.     }
  86. }
  87.  
  88. void PtoPCstrncpy( /* PCstr *dest, char *src, short n */)
  89. {
  90.     asm 68000 {
  91.         movea.l    8(sp),a0    ; a0 = src
  92.         movea.l    4(sp),a1    ; a1 = dest
  93.         move.w    12(sp),d0    ; d0 = n
  94.         clr.w    d1
  95.         move.b    (a0)+,d1
  96.         cmp.w    d0,d1
  97.         bcc.s    @skip
  98.         move.w    d1,d0
  99.     @skip:
  100.         move.b    d0,(a1)+
  101.         subq.w    #1,d0
  102.         bcs.s    @exit
  103.     @loop:
  104.         move.b    (a0)+,(a1)+
  105.         dbf        d0,@loop
  106.     @exit:
  107.     }
  108. }
  109.  
  110. void CtoPCstrncpy( /* PCstr *dest, char *src, short n */ )
  111. {
  112.     asm 68000 {
  113.         movea.l    8(sp),a0    ; a0 = src
  114.         movea.l    4(sp),a1    ; a1 = dest
  115.         addq.l    #1,a1
  116.         clr.w    d1
  117.         move.w    12(sp),d0    ; d0 = n
  118.         bra.s    @skip
  119.     @loop:
  120.         addq.w    #1,d1
  121.         move.b    (a0)+,(a1)+
  122.     @skip:
  123.         dbeq.w    d0,@loop
  124.         clr.b    (a1)
  125.         movea.l    4(sp),a1    ; a1 = dest
  126.         subq.w    #1,d1
  127.         move.b    d1,(a1)
  128.     }
  129. }
  130.  
  131. void PtoPCstrcat( /* PCstr *dest, char *src */ )
  132. {
  133.     asm 68000 {
  134.         movea.l    8(sp),a0    ; a0 = src
  135.         movea.l    4(sp),a1    ; a1 = dest
  136.         clr.w    d0
  137.         clr.w    d1
  138.         move.b    (a0)+,d0
  139.         move.b    (a1),d1
  140.         add.b    d0,(a1)
  141.         lea.l    1(a1,d1),a1
  142.         bra.s    @skip
  143.     @loop:
  144.         move.b    (a0)+,(a1)+
  145.     @skip:
  146.         dbf.w    d0,@loop
  147.         clr.b    (a1)
  148.     }
  149. }
  150.  
  151. void CtoPCstrcat( /* PCstr *dest, char *src */ )
  152. {
  153.     asm 68000 {
  154.         movea.l    8(sp),a0    ; a0 = src
  155.         movea.l    4(sp),a1    ; a1 = dest
  156.         clr.w    d0
  157.         move.b    (a1),d0
  158.         lea.l    1(a1,d0),a1
  159.         subq.w    #1,d0
  160.     @loop:
  161.         addq.w    #1,d0
  162.         move.b    (a0)+,(a1)+
  163.         bne.s    @loop
  164.         movea.l    4(sp),a1    ; a1 = dest
  165.         move.b    d0,(a1)
  166.     }
  167. }
  168.  
  169. PCstr *PtoPCstr( /* char *str */ )
  170. {
  171.     asm 68000 {
  172.         movea.l    4(sp),a0    ; a0 = str
  173.         clr.w    d0
  174.         move.b    (a0),d0
  175.         clr.b    1(a0,d0)
  176.         move.l    a0,d0
  177.     }
  178. }
  179.  
  180. PCstr *CtoPCstr( /* char *str */)
  181. {
  182.     asm 68000 {
  183.         movea.l    4(sp),a0    ; a0 = str
  184.         move.b    (a0)+,d0
  185.         lea.l    (a0),a1
  186.     @loop:
  187.         move.b    (a1),d1
  188.         move.b    d0,(a1)+
  189.         move.b    d1,d0
  190.         bne.s    @loop
  191.         move.b    d0,(a1)
  192.         suba.l    a0,a1
  193.         move.l    a1,d0
  194.         move.b    d0,-(a0)
  195.         move.l    a0,d0
  196.     }
  197. }
  198.  
  199. void SetPlen( /* PCstr *pcstr */ )
  200. {
  201.     asm 68000 {
  202.         movea.l    4(sp),a0    ; a0 = str
  203.         lea.l    1(a0),a1
  204.         moveq.l    #-1,d0
  205.     @loop:
  206.         addq.w    #1,d0
  207.     @skip:
  208.         tst.b    (a1)+
  209.         bne.s    @loop
  210.         move.b    d0,(a0)
  211.     }
  212. }
  213. #else
  214. /* C function prototypes in mac_napp.h */
  215. #include "macnapp.h"
  216.  
  217. void PtoPCstrcpy(dest, src)
  218.     register PCstr    *dest;
  219.     register char    *src;
  220. {
  221.     register short    i;
  222.     
  223.     i = Pstrlen(src);
  224.     C(dest)[i] = '\0';
  225.     do {
  226.         *dest++ = *src++;
  227.     } while (i--);
  228. }
  229.  
  230. void CtoPCstrcpy(dest, src)
  231.     register PCstr    *dest;
  232.     register char    *src;
  233. {
  234.     register short    i;
  235.     register char    *cpy;
  236.  
  237.     cpy = C(dest);
  238.     for (i = 0; *cpy++ = *src++; i++);
  239.     *dest = i;
  240. }
  241.  
  242. void PCtoPCstrcpy(dest, src)
  243.     register PCstr    *dest;
  244.     register PCstr    *src;
  245. {
  246.     *dest++ = *src++;
  247.     while (*dest++ = *src++);
  248. }
  249.  
  250. void PtoPCstrncpy(PCstr *dest, char *src, short n)
  251. {
  252.     if (Pstrlen(src) < n) n = Pstrlen(src);
  253.     *dest++ = n;
  254.     src++;
  255.     while (n--) *dest++ = *src++;
  256.     *dest++ = '\0';
  257. }
  258.  
  259. void CtoPCstrncpy(PCstr *dest, char *src, short n)
  260. {
  261.     register char    *tmp;
  262.     register short    i;
  263.     
  264.     tmp = C(dest);
  265.     for (i = 0; n-- && (*tmp++ = *src++); i++);
  266.     *tmp = '\0';
  267.     *dest = i;
  268. }
  269.  
  270. void PtoPCstrcat(dest, src)
  271.     register PCstr    *dest;
  272.     register char    *src;
  273. {
  274.     register short    i;
  275.     register short    j;
  276.     
  277.     i = *dest;
  278.     *dest += (j = (unsigned char) *src++);
  279.     dest += i + 1;
  280.     while (j--) *dest++ = *src++;
  281.     *dest = '\0';
  282. }
  283.  
  284. void CtoPCstrcat(dest, src)
  285.     register PCstr    *dest;
  286.     register char    *src;
  287. {
  288.     register short    i;
  289.     register char    *tmp;
  290.     
  291.     tmp = (char *) dest + (i = *dest) + 1;
  292.     while (*tmp++ = *src++) i++;
  293.     *dest = i;
  294. }
  295.  
  296. PCstr *PtoPCstr(str)
  297.     register char    *str;
  298. {
  299.     SetClen((PCstr*) str);
  300.  
  301.     return ((PCstr*) str);
  302. }
  303.  
  304. PCstr *CtoPCstr(str)
  305.     register char    *str;
  306. {
  307.     register PCstr    i;
  308.     register char    c, d;
  309.     register char    *tmp;
  310.     
  311.     i = 0;
  312.     tmp = str;
  313.     tmp++;
  314.     c = *tmp++;
  315.     do {
  316.         d = *tmp;
  317.         *tmp++ = c;
  318.         i++;
  319.     } while (c = d);
  320.     (*(PCstr*)str) = i;
  321.         
  322.     return ((PCstr*) str);
  323. }
  324.  
  325. void SetPlen(pcstr)
  326.     register PCstr    *pcstr;
  327. {
  328.     register short    i = -1;
  329.     register char    *len = C(pcstr);
  330.     
  331.     do {
  332.         i++;
  333.     } while (*len++);
  334.     
  335.     *pcstr = i;
  336. }
  337. #endif
  338.  
  339. /* simple procedure to convert decimal number of 
  340.  * less than 20 digits to a PC string.
  341.  * Compiling with 68020 option makes this quite a bit more efficient.
  342.  */
  343. PCstr *longtoPCstr(i)
  344.     register long i;
  345. {
  346.     static PCstr               sbuf[21];
  347.     register Boolean           negflag;
  348.     register unsigned long     val, ten = 10;
  349.     register PCstr             *pos = sbuf + sizeof (sbuf) - 1;
  350.     register PCstr             *posst;
  351.  
  352.     *pos = '\0';
  353.     posst = --pos;
  354.     negflag = false;
  355.     val = i;
  356.     if (i < 0) {
  357.         negflag = true;
  358.         val = -i;
  359.     }
  360.     do {
  361.         *pos = (unsigned short) (val % ten) + '0';
  362.         pos--;
  363.     } while (val /= ten);
  364.     if (negflag) {
  365.         *pos = '-';
  366.         pos--;
  367.     }
  368.     *pos = posst - pos;
  369.  
  370.     return (pos);
  371. }
  372.  
  373.